home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / dev / src / td01_src.lha / td_r0.1 / sl3 / source / geoa / geoa.c next >
Encoding:
C/C++ Source or Header  |  1999-06-19  |  20.3 KB  |  811 lines
  1. /*
  2. **      $VER: geoa.c 1.00 (19.6.1999)
  3. **
  4. **      Creation date : 8.5.1999
  5. **
  6. **      Description       :
  7. **         Standart 3d extension module for tdo.library.
  8. **         Loads and saves the mesh as Videoscape ASCII file.
  9. **
  10. **
  11. **      Written by Stephan Bielmann
  12. **
  13. */
  14.  
  15. /*************************** Includes *******************************/
  16.  
  17. /*
  18. ** Ansi C includes
  19. */
  20. #include <math.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24.  
  25. /*
  26. ** Amiga includes
  27. */
  28. #include <dos/dos.h>
  29. #include <dos/stdio.h>
  30.  
  31. #include <clib/dos_protos.h>
  32.  
  33. /*
  34. ** Project includes
  35. */
  36. #include "td_public.h"
  37. #include "compiler.h"
  38. #include "td.h"
  39.  
  40. /**************************** Defines *******************************/
  41.  
  42. /*
  43. ** Number of elements in the buffers
  44. */
  45. #define Ci_MAXVERINPOLY 200    // maximum vertices in a polygon
  46.  
  47. /*********************** Type definitions ***************************/
  48.  
  49. /*
  50. ** Color structure
  51. */
  52. struct TColor {
  53.     UBYTE r,g,b;
  54. };
  55.  
  56. /*************************** Variables ******************************/
  57.  
  58. /*
  59. ** Videoscape equivalent rgb colors.
  60. */
  61. static const TColor colorTbl[] = {
  62. {  0,  0,  0},{  0,  0,178},{  0,178,  0},{  0,178,178},{178,  0,  0},{255,127,255},
  63. {204,153,102},{127,127,127},{  0,  0,  0},{102,102,255},{102,255,102},{  0,255,100},
  64. {255,102,102},{255,204,255},{255,255,  0},{255,255,255}
  65. };
  66.  
  67. /********************** Private functions ***************************/
  68.  
  69. /********************************************************************\
  70. *                                                                    *
  71. * Name         : magnitude                                           *
  72. *                                                                    *
  73. * Description  : Calculates the magnitude of a color vector.         *
  74. *                                                                    *
  75. * Arguments    : x,y,z : Color vector.                               *
  76. *                                                                    *
  77. * Return Value : Vector its magnitude.                               *
  78. *                                                                    *
  79. * Comment      :                                                     *
  80. *                                                                    *
  81. \********************************************************************/
  82. static ULONG magnitude(LONG x, LONG y, LONG z)
  83. {
  84.     return(sqrt(x*x + y*y + z*z));
  85. }
  86.  
  87. /********************************************************************\
  88. *                                                                    *
  89. * Name         : index2Color                                         *
  90. *                                                                    *
  91. * Description  : Converts a GEO color index into a RGB color.        *
  92. *                                                                    *
  93. * Arguments    : index : The color index.                            *
  94. *                                                                    *
  95. * Return Value : Vector its magnitude.                               *
  96. *                                                                    *
  97. * Comment      :                                                     *
  98. *                                                                    *
  99. \********************************************************************/
  100. static TColor index2Color(ULONG index)
  101. {
  102.     static TColor col;
  103.     
  104.     /*
  105.     ** Check range
  106.     */
  107.     if (index >= 0 && index < sizeof(colorTbl)/sizeof(TColor)) {
  108.         /*
  109.         ** return table entry
  110.         */
  111.         col.r = colorTbl[index].r;
  112.         col.g= colorTbl[index].g;
  113.         col.b= colorTbl[index].b;
  114.  
  115.         return (col);
  116.     }
  117.  
  118.     /*
  119.     ** Out-of-range color is white, like undefined.
  120.     */
  121.     col.r = 255;
  122.     col.g= 255;
  123.     col.b= 255;
  124.                 
  125.     return (col);
  126. }
  127.  
  128. /********************************************************************\
  129. *                                                                    *
  130. * Name         : color2GEO                                           *
  131. *                                                                    *
  132. * Description  : Matches the nearest color available in the GEO      *
  133. *                color palette.                                      *
  134. *                                                                    *
  135. * Arguments    : red,green,blue : Color values.                      *
  136. *                                                                    *
  137. * Return Value : GEO color index.                                    *
  138. *                                                                    *
  139. * Comment      :                                                     *
  140. *                                                                    *
  141. \********************************************************************/
  142. static ULONG color2GEO (UBYTE red, UBYTE green, UBYTE blue)
  143. {
  144.     ULONG            i;
  145.     ULONG            index = 1;
  146.     TColor            current;
  147.     LONG            best;
  148.     LONG            difference;
  149.   
  150.     current = index2Color(index);
  151.     best =  magnitude(current.r-red,current.g-green,current.b-blue);
  152.  
  153.     for (i = 0; i < sizeof(colorTbl)/sizeof(TColor); i++) {
  154.         current = index2Color(i);
  155.         difference = magnitude(current.r-red,current.g-green,current.b-blue);
  156.         if (difference < best) {
  157.             best = difference;
  158.             index = i;
  159.         }
  160.     }
  161.  
  162.     return (index);
  163. }
  164.  
  165. /********************** Public functions ****************************/
  166.  
  167. /****** geoa.library/td3XSave ******************************************
  168. * 
  169. *   NAME    
  170. *     td3XSave -- Saves the whole space or one to several
  171. *                components of it as a 3D file.
  172. *
  173. *   SYNOPSIS
  174. *    error = td3XSave( spacehandle,filename,type,index,screen)
  175. *                      D1          D2       D3   D4     A0
  176. *
  177. *    TDerrors td3XSave
  178. *         ( ULONG,STRPTR,TDenum,ULONG,struct Screen " );
  179. *
  180. *   FUNCTION
  181. *    The space will be saved in a 3 dimensional representation in the
  182. *    filename, without existence checks.
  183. *    By specifying type, you can save multiple components, all surfaces
  184. *    for example, and by defining index, a single component. One
  185. *    object for example.
  186. *
  187. *    The screen parameter is optional and this functions uses it
  188. *    only if it is set non-NULL, to display a window with
  189. *    additional or special parameters needed to save the file,
  190. *    or for messages.
  191. * 
  192. *   INPUTS
  193. *     spacehandle   - A valid handle of a space.
  194. *    filename      - Name of the file to create.
  195. *    type          - Type of component to save.
  196. *    index         - Index of the component.
  197. *    screen        - Pointer to the work screen.
  198. *    
  199. *   RESULT
  200. *     error - ER_NOERROR      if all went well.
  201. *            ER_NOTYPE       if the type is not supported.
  202. *            ER_NOVERTEX     if there are no vertices
  203. *            ER_NOPOLYGON    if there are no polygons
  204. *            ER_NOMATGROUP   if there are no material groups
  205. *            ER_OVERFLOW     if the component is to big to save.
  206. *            ER_CREATEFILE   if the file can not be created.
  207. *            ER_WRITEDATA    if an error occured while writing data.
  208.  
  209.  
  210.  
  211. *            NOTIMPL      if the function is not implemented.
  212. *            NOMEMORY     if there is not enough memory. 
  213. *            NOMATERIAL   if there are no materials, but they are expected.
  214. *            td errors    if a td call failed.
  215.  
  216.  
  217. * 
  218. *   EXAMPLE
  219. *    error = td3XSave(spacehandle,"ram:test",TD_OBJECT,4,NULL);
  220. *
  221. *   NOTES
  222. *
  223. *   BUGS
  224. * 
  225. *   SEE ALSO
  226. * 
  227. ******************************************************************************
  228. *
  229. */
  230. TDerrors __saveds ASM td3XSave(register __d1 ULONG spacehandle,
  231.                                 register __d2 STRPTR filename,
  232.                                 register __d3 TDenum type,
  233.                                 register __d4 ULONG index,
  234.                                 register __a0 struct Screen *screen) {
  235.  
  236.     BPTR            geofile=NULL;
  237.     ULONG            space,nofv,nofpo,nofmg,mat,i,j,n,vi;
  238.     TDenum            rt;
  239.     TDvectorf        vertex;
  240.     UBYTE            color[3];
  241.     UBYTE            buffer[150];
  242.  
  243.  
  244.     space=spacehandle;
  245.  
  246.     // check the type for the type of output
  247.     switch(type) {
  248.         case TD_OBJECT :
  249.         case TD_POLYMESH :
  250.             tdTypeGet(space,TD_OBJECT,index,&rt);
  251.  
  252.             if(rt==TD_POLYMESH) {
  253.                 tdCurrent(space,TD_OBJECT,index);
  254.  
  255.                 // Check if there are some vertices
  256.                 nofv=tdNofGet(space,TD_VERTEX);
  257.                 if(nofv==0) {
  258.                     return(ER_NOVERTEX);
  259.                 }
  260.                 // Maximum of 65536 vertices
  261.                 if(nofv>65536) {
  262.                     return(ER_OVERFLOW);
  263.                 }
  264.  
  265.                 // Check if there are some polygons
  266.                 nofpo=tdNofGet(space,TD_POLYGON);
  267.                 if(nofpo==0) {
  268.                     return(ER_NOPOLYGON);
  269.                 }
  270.  
  271.                 // Check if there are some matgroups.
  272.                 nofmg=tdNofGet(space,TD_MATGROUP);
  273.                 if(nofmg==0) {
  274.                     return(ER_NOMATGROUP);
  275.                 }
  276.  
  277.                 /* Open the file for output */
  278.                 if((geofile=Open(filename,MODE_NEWFILE))==NULL) return(ER_CREATEFILE);
  279.     
  280.                 /* Change the buffer size of the filehandle to 10k */
  281.                 if (SetVBuf(geofile,NULL,BUF_FULL,10000)!=DOSFALSE) {
  282.                     Close(geofile);
  283.                     return(ER_NOMEMORY);
  284.                 }
  285.  
  286.                 // Write the header and the number of vertices
  287.                 if (FPrintf(geofile,"3DG1\n%ld\n",nofv)==ENDSTREAMCH) {
  288.                     Close(geofile);
  289.                     return(ER_WRITEDATA);
  290.                 }
  291.  
  292.                 // Write the vertices              
  293.                 for(i=1;i<=nofv;i++) {
  294.                     tdVertexGetfv(space,i,&vertex);
  295.                     sprintf(buffer,"%0.4g %0.4g %0.4g\n",vertex.x,vertex.z,vertex.y);
  296.                     if(FPuts(geofile,buffer)!=DOSFALSE) {
  297.                         Close(geofile);
  298.                         return(ER_WRITEDATA);
  299.                     }
  300.                 }
  301.  
  302.                 // Get all matgroups and write down theyr polygons with material
  303.                 for(i=1;i<=nofmg;i++) {
  304.                     tdCurrent(space,TD_MATGROUP,i);
  305.                     if((nofpo=tdNofGet(space,TD_POLYGON))>0) {
  306.                         for(j=1;j<=nofpo;j++) {
  307.                             tdCurrent(space,TD_POLYGON,j);
  308.                             if((nofv=tdNofGet(space,TD_VERTEX))>0) {
  309.                                 // writing the number of vertices in this polygon
  310.                                 if (FPrintf(geofile,"%ld ",nofv)==ENDSTREAMCH) {
  311.                                     Close(geofile);
  312.                                     return(ER_WRITEDATA);
  313.                                 }
  314.                                 for(n=nofv;n>0;n--) {
  315.                                     // handle = index + 1
  316.                                     tdVertexIndexGet(space,n,&vi);
  317.                                     if (FPrintf(geofile,"%ld ",vi-1)==ENDSTREAMCH) {
  318.                                         Close(geofile);
  319.                                         return(ER_WRITEDATA);
  320.                                     }
  321.                                 }
  322.                                 tdChildGetl(space,TD_MATERIAL,&mat);
  323.                                 tdMaterialGetuba(space,TD_DIFFUSE,mat,color);
  324.                                 // write the material index
  325.                                 if (FPrintf(geofile,"%ld\n",color2GEO(color[0],color[1],color[2]))==ENDSTREAMCH) {
  326.                                     Close(geofile);
  327.                                     return(ER_WRITEDATA);
  328.                                 }
  329.                             }
  330.                         }
  331.                     }
  332.                 }
  333.  
  334.                 // Close the file
  335.                 Close(geofile);
  336.             } else {
  337.                 return(ER_NOTYPE);
  338.             }
  339.             break;
  340.         default :
  341.             return(ER_NOTYPE);
  342.     }
  343.  
  344.     return(ER_NOERROR);
  345. }
  346.  
  347. /****** geoa.library/td3XLoad ******************************************
  348. * 
  349. *   NAME    
  350. *     td3XLoad -- Load the whole 3D file, or components out of
  351. *                it into a space.
  352. *
  353. *   SYNOPSIS
  354. *    error = td3XLoad( spacehandle,filename,type,screen,erroffset)
  355. *                      D1          D2       D3    A0    D4
  356. *
  357. *    TDerrors td3XLoad
  358. *         ( ULONG,STRPTR,TDenum,struct Screen " ,ULONG *);
  359. *
  360. *   FUNCTION
  361. *    A file which contains a 3 dimensional represantation will
  362. *    be examined for known components and loaded into the
  363. *    space.
  364. *    By defining another type you can load single components
  365. *    into the space, materials only, or similar.
  366. *
  367. *    The screen parameter is optional and this functions uses it
  368. *    only if it is set non-NULL, to display a window with
  369. *    additional or special parameters needed to save the file,
  370. *    or for messages.
  371. * 
  372. *   INPUTS
  373. *     spacehandle   - A valid handle of a space.
  374. *    filename      - Name of the file to load.
  375. *    type          - Type of component to load.
  376. *    screen        - Pointer to the work screen.
  377. *    erroffset     - Offset where a read error occured.
  378. *    
  379. *   RESULT
  380. *     error - ER_NOERROR       if all went well.
  381. *            ER_NOFILE        if the file is not found.
  382. *            ER_READDATA      if an error occured while reading data.
  383. *            ER_NOMEMORY      if there is not enough memory. 
  384. *            ER_UNKNOWNFORMAT if the file format is unknown.
  385. *            ER_NOVERTEX      if there are no vertices.
  386.  
  387. *            RCNOTIMPL       if the function is not implemented.
  388. *            RCNOMATERIAL    if there are no materials, but they are expected.
  389. *           RCNOPART        if there are no parts, but they are expected.
  390. *            RCNOPOLYGON     if there are no polygons, but they are expected.
  391. *            tdo errors      if a tdo call failed.
  392. * 
  393. *   EXAMPLE
  394. *    error = td3XLoad(spacehandle,"ram:test",TD_SPACE,NULL);
  395. *
  396. *   NOTES
  397. *
  398. *   BUGS
  399. * 
  400. *   SEE ALSO
  401. * 
  402. ******************************************************************************
  403. *
  404. */
  405. TDerrors __saveds ASM td3XLoad(register __d1 ULONG spacehandle,
  406.                                 register __d2 STRPTR filename,
  407.                                 register __d3 TDenum type,
  408.                                 register __a0 struct Screen *screen,
  409.                                 register __d4 ULONG *erroffset) {
  410.  
  411.     ULONG space;
  412.     FILE *fp=NULL;
  413.     char header[10];
  414.     unsigned long vertices=0,polygons=0;
  415.     long material=0,pt=0;
  416.     unsigned long points[1000];
  417.     long i,j,det;
  418.     TDvectorf v;
  419.     TColor color;
  420.     UBYTE ca[3];
  421.  
  422.  
  423.     space=spacehandle;
  424.  
  425.     // check the type for the type of output
  426.     switch(type) {
  427.         case TD_OBJECT :
  428.         case TD_POLYMESH :
  429.             fp=fopen(filename,"r");
  430.             if(fp==NULL) {
  431.                 return(ER_NOFILE);
  432.             }
  433.  
  434.             // initializing the line counter
  435.             (*erroffset)=1;
  436.  
  437.             fscanf(fp,"%4s",header);
  438.             if(strncmp(header,"3DG1",4)!=0) {
  439.                 fclose(fp);
  440.                 return(ER_UNKNOWNFORMAT);
  441.             }
  442.         
  443.             (*erroffset)++;
  444.  
  445.             fscanf(fp,"%ld",&vertices);
  446.             if(vertices==0) {
  447.                 fclose(fp);
  448.                 return(ER_NOVERTEX);
  449.             }
  450.  
  451.             (*erroffset)++;
  452.     
  453.             // creating a new polymesh
  454.             if(tdAdd(space,TD_POLYMESH)!=ER_NOERROR) {
  455.                 fclose(fp);
  456.                 return(ER_NOMEMORY);
  457.             }
  458.             tdCurrent(space,TD_OBJECT,tdNofGet(space,TD_OBJECT));
  459.  
  460.             // initialize the materials and parts
  461.             for(i=0;i<16;i++) {
  462.                 if(tdAdd(space,TD_SURFACE)!=ER_NOERROR) {
  463.                     fclose(fp);
  464.                     return(ER_NOMEMORY);
  465.                 }
  466.  
  467.                 color=colorTbl[i];
  468.                 ca[0]=color.r;ca[1]=color.g;ca[2]=color.b;
  469.                 tdMaterialSetuba(space,TD_DIFFUSE,j=tdNofGet(space,TD_MATERIAL),ca);
  470.  
  471.                 tdCurrent(space,TD_MATERIAL,j);
  472.                 if(tdBegin(space,TD_MATGROUP)!=ER_NOERROR) {
  473.                     fclose(fp);
  474.                     return(ER_NOMEMORY);
  475.                 }
  476.             }
  477.  
  478.             // ensure no currents
  479.             tdEnd(space,TD_MATERIAL);
  480.             tdEnd(space,TD_MATGROUP);
  481.  
  482.             for(i=0;i<vertices;i++,(*erroffset)++) {
  483.                 // GEO z equals to the libraries y
  484.                 if(fscanf(fp,"%f %f %f",&v.x,&v.z,&v.y)==EOF) {
  485.                     fclose(fp);
  486.                     return(ER_READDATA);
  487.                 }
  488.  
  489.                 if(tdVertexAddfv(space,&v)!=ER_NOERROR) {
  490.                     fclose(fp);
  491.                     return(ER_NOMEMORY);
  492.                 }
  493.             }
  494.  
  495.             // reseting detail polygon indicator and polygon count
  496.             // to be able to catch empty lines.
  497.             det=0;
  498.             polygons=0;
  499.  
  500.             while(fscanf(fp,"%ld",&polygons)!=EOF) {
  501.                 // we limit us to Ci_MAXVERINPOLY points per polygon, and skip detail polygons
  502.                 if(polygons>0 && det==0) {
  503.                     for(i=0;i<polygons&&i<Ci_MAXVERINPOLY;i++) {
  504.                         if(fscanf(fp,"%ld",&(points[i]))==EOF) {
  505.                             fclose(fp);
  506.                             return(ER_READDATA);
  507.                         } else {
  508.                             if(points[i]>=vertices) {
  509.                                 fclose(fp);
  510.                                 return(ER_READDATA);
  511.                             }
  512.                         }
  513.                     }
  514.                 } else {
  515.                     // skip all detail polys
  516.                     det=polygons;
  517.                     for(j=0;j<det;j++) {
  518.                         if(fscanf(fp,"%ld",&polygons)!=EOF) {
  519.                             for(i=0;i<=polygons;i++) {
  520.                                 if(fscanf(fp,"%ld",&pt)==EOF) {
  521.                                     fclose(fp);
  522.                                     return(ER_READDATA);
  523.                                 }
  524.                             }
  525.                             polygons=0;
  526.                             (*erroffset)++;
  527.                         }
  528.                     }
  529.  
  530.                     polygons=0;
  531.                     det=0;
  532.                     continue;
  533.                 }
  534.  
  535.                 if(fscanf(fp,"%ld",&material)==EOF) {
  536.                     fclose(fp);
  537.                     return(ER_READDATA);
  538.                 } else {
  539.  
  540.                     // we are using only 16 out of 256 colors.
  541.                     // and we skip detail polygons, color = minus
  542.                     if (material<0) {
  543.                         material*=-1;
  544.                         det=-1;
  545.                     }
  546.                     tdCurrent(space,TD_MATGROUP,(material%16)+1);
  547.                     if(tdBegin(space,TD_POLYGON)!=ER_NOERROR) {
  548.                         fclose(fp);
  549.                         return(ER_NOMEMORY);
  550.                     }
  551.                 }
  552.  
  553.                 // remember, GEO is clockwise, the library counterclockwise
  554.                 for(i=polygons-1;i>=0;i--) {
  555.                     if(tdVertexAssign(space,points[i]+1)!=ER_NOERROR) {
  556.                         fclose(fp);
  557.                         return(ER_NOMEMORY);
  558.                     }
  559.                 }
  560.                 tdEnd(space,TD_POLYGON);
  561.  
  562.                 (*erroffset)++;
  563.                 polygons=0;
  564.             }
  565.  
  566.             fclose(fp);
  567.  
  568.             tdEnd(space,TD_OBJECT);
  569.             
  570.             break;
  571.         default :
  572.             return(ER_NOTYPE);
  573.     }
  574.  
  575.     return(ER_NOERROR);
  576. }
  577.  
  578. /****** geoa.library/td3XCheckFile ******************************************
  579. * 
  580. *   NAME    
  581. *     td3XCheckFile -- Checks if the file is in the format we expected to load.
  582. *
  583. *   SYNOPSIS
  584. *    error = td3XLoad( filename )
  585. *                      D1
  586. *
  587. *    TDerrors td3XCheckFile
  588. *         ( STRPTR );
  589. *
  590. *   FUNCTION
  591. *    The file its header will be examinated to verify if it is the
  592. *    file format we expect to read with the load function.
  593. * 
  594. *   INPUTS
  595. *    filename      - Name of the file to load.
  596. *    
  597. *   RESULT
  598. *     error - ER_NOERROR       if all went well.
  599. *            ER_UNKNOWNFORMAT if the file format is unknown.
  600. *            ER_NOFILE        if the file is not found.
  601. *            ER_READDATA      if an error occured while reading data.
  602. * 
  603. *   EXAMPLE
  604. *    error = td3XCheckFile("ram:test");
  605. *
  606. *   NOTES
  607. *
  608. *   BUGS
  609. * 
  610. *   SEE ALSO
  611. * 
  612. ******************************************************************************
  613. *
  614. */
  615. TDerrors __saveds ASM td3XCheckFile(register __d2 STRPTR filename) {
  616.  
  617.     FILE *fp=NULL;
  618.     char header[10];
  619.  
  620.     // open the file for input
  621.     fp=fopen(filename,"r");
  622.     if(fp==NULL) {
  623.         return(ER_NOFILE);
  624.     }
  625.  
  626.     // check the file type
  627.     fscanf(fp,"%4s",header);
  628.     fclose(fp);
  629.  
  630.     if(strncmp(header,"3DG1",4)!=0) {
  631.         return(ER_UNKNOWNFORMAT);
  632.     }
  633.  
  634.     return(ER_NOERROR);
  635. }
  636.  
  637. /****** geoa.library/td3XExt ******************************************
  638. * 
  639. *   NAME    
  640. *     td3XExt -- Returns the default extension of the file format.
  641. *
  642. *   SYNOPSIS
  643. *    ext = td3XExt ( )
  644. *
  645. *    STRPTR td3XExt
  646. *         ( );
  647. *
  648. *   FUNCTION
  649. *    The default extension of the file format will be returned
  650. *    as READ_ONLY, NULL terminated string which will be only valid
  651. *    as long as the library is opened.
  652. * 
  653. *   INPUTS
  654. *    
  655. *   RESULT
  656. *     ext - String pointer to the extension, or NULL no default.
  657. * 
  658. *   EXAMPLE
  659. *    ext = td3XExt();
  660. *
  661. *   NOTES
  662. *
  663. *   BUGS
  664. * 
  665. *   SEE ALSO
  666. * 
  667. ******************************************************************************
  668. *
  669. */
  670. STRPTR __saveds ASM td3XExt () {
  671.     static STRPTR ext="geo";
  672.  
  673.     return(ext);
  674. }
  675.  
  676. /****** geoa.library/td3XName ******************************************
  677. * 
  678. *   NAME    
  679. *     td3XName -- Returns the file format name string.
  680. *
  681. *   SYNOPSIS
  682. *    name = td3XName ( )
  683. *
  684. *    SRPTR td3XName
  685. *         ( );
  686. *
  687. *   FUNCTION
  688. *    The file format its name will be returned. This string should not 
  689. *    be to large, about 20 characters maximum.
  690. *    The string is READ_ONLY, NULL terminated and only valid as
  691. *    long as the library is opened.
  692. * 
  693. *   INPUTS
  694. *    
  695. *   RESULT
  696. *     name - String pointer to the name, or NULL no one.
  697. * 
  698. *   EXAMPLE
  699. *    name = td3XName();
  700. *
  701. *   NOTES
  702. *
  703. *   BUGS
  704. * 
  705. *   SEE ALSO
  706. * 
  707. ******************************************************************************
  708. *
  709. */
  710. STRPTR __saveds ASM td3XName () {
  711.     static STRPTR name="Videoscape ASCII (TD)";
  712.  
  713.     return(name);
  714. }
  715.  
  716. /****** geoa.library/td3XSaverSupports *************************************
  717. * 
  718. *   NAME    
  719. *     td3XSaverSupports -- This function has to indicate if the saver
  720. *                        is supporting a type of save functionality
  721. *                        or not.
  722. *
  723. *   SYNOPSIS
  724. *    supported = td3XSaverSupports(type)
  725. *                                  D1
  726. *
  727. *    ULONG td3XSaverSupports
  728. *         ( TDenum );
  729. *
  730. *   FUNCTION
  731. *    The main library checks with this function, which types of
  732. *    save possibilities can be made in this module.
  733. * 
  734. *   INPUTS
  735. *    type          - Type of save functionality.
  736. *    
  737. *   RESULT
  738. *     supported - 0 if not and 1 if supported.
  739. * 
  740. *   EXAMPLE
  741. *    supported = td3XSaverSupports(TD_OBJECT);
  742. *
  743. *   NOTES
  744. *
  745. *   BUGS
  746. * 
  747. *   SEE ALSO
  748. * 
  749. ******************************************************************************
  750. *
  751. */
  752. ULONG __saveds ASM td3XSaverSupports(register __d1 TDenum type) {
  753.     switch(type) {
  754.         case TD_OBJECT:
  755.         case TD_POLYMESH:
  756.             return(1);
  757.  
  758.         default:
  759.             return(0);
  760.     }
  761. }
  762.  
  763. /****** geoa.library/td3XLoaderSupports *************************************
  764. * 
  765. *   NAME    
  766. *     td3XLoaderSupports -- This function has to indicate if the loader
  767. *                         is supporting a type of load functionality
  768. *                         or not.
  769. *
  770. *   SYNOPSIS
  771. *    supported = td3XloaderSupports(type)
  772. *                                   D1
  773. *
  774. *    ULONG td3XLoaderSupports
  775. *         ( TDenum );
  776. *
  777. *   FUNCTION
  778. *    The main library checks with this function, which types of
  779. *    load possibilities can be made in this module.
  780. * 
  781. *   INPUTS
  782. *    type          - Type of save functionality.
  783. *    
  784. *   RESULT
  785. *     supported - 0 if not and 1 if supported.
  786. * 
  787. *   EXAMPLE
  788. *    supported = td3XLoaderSupports(TD_OBJECT);
  789. *
  790. *   NOTES
  791. *
  792. *   BUGS
  793. * 
  794. *   SEE ALSO
  795. * 
  796. ******************************************************************************
  797. *
  798. */
  799. ULONG __saveds ASM td3XLoaderSupports(register __d1 TDenum type) {
  800.     switch(type) {
  801.         case TD_OBJECT:
  802.         case TD_POLYMESH:
  803.             return(1);
  804.  
  805.         default:
  806.             return(0);
  807.     }
  808. }
  809.  
  810. /************************* End of file ******************************/
  811.